home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / bsddb / dbshelve.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-11-11  |  12.9 KB  |  348 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Manage shelves of pickled objects using bsddb database files for the
  5. storage.
  6. '''
  7. import cPickle
  8. import sys
  9. import sys
  10. absolute_import = sys.version_info[0] >= 3
  11. if absolute_import:
  12.     exec 'from . import db'
  13. else:
  14.     import db
  15. if sys.version_info[:3] >= (2, 3, 0):
  16.     HIGHEST_PROTOCOL = cPickle.HIGHEST_PROTOCOL
  17.     if sys.version_info[:3] < (2, 4, 0):
  18.         
  19.         def _dumps(object, protocol):
  20.             return cPickle.dumps(object, protocol)
  21.  
  22.     else:
  23.         
  24.         def _dumps(object, protocol):
  25.             return cPickle.dumps(object, protocol = protocol)
  26.  
  27. else:
  28.     HIGHEST_PROTOCOL = None
  29.     
  30.     def _dumps(object, protocol):
  31.         return cPickle.dumps(object, bin = protocol)
  32.  
  33. if sys.version_info[0:2] <= (2, 5):
  34.     
  35.     try:
  36.         from UserDict import DictMixin
  37.     except ImportError:
  38.         
  39.         class DictMixin:
  40.             pass
  41.  
  42.  
  43.     MutableMapping = DictMixin
  44. else:
  45.     import collections
  46.     MutableMapping = collections.MutableMapping
  47.  
  48. def open(filename, flags = db.DB_CREATE, mode = 432, filetype = db.DB_HASH, dbenv = None, dbname = None):
  49.     '''
  50.     A simple factory function for compatibility with the standard
  51.     shleve.py module.  It can be used like this, where key is a string
  52.     and data is a pickleable object:
  53.  
  54.         from bsddb import dbshelve
  55.         db = dbshelve.open(filename)
  56.  
  57.         db[key] = data
  58.  
  59.         db.close()
  60.     '''
  61.     if type(flags) == type(''):
  62.         sflag = flags
  63.         if sflag == 'r':
  64.             flags = db.DB_RDONLY
  65.         elif sflag == 'rw':
  66.             flags = 0
  67.         elif sflag == 'w':
  68.             flags = db.DB_CREATE
  69.         elif sflag == 'c':
  70.             flags = db.DB_CREATE
  71.         elif sflag == 'n':
  72.             flags = db.DB_TRUNCATE | db.DB_CREATE
  73.         else:
  74.             raise db.DBError, "flags should be one of 'r', 'w', 'c' or 'n' or use the bsddb.db.DB_* flags"
  75.     sflag == 'r'
  76.     d = DBShelf(dbenv)
  77.     d.open(filename, dbname, filetype, flags, mode)
  78.     return d
  79.  
  80.  
  81. class DBShelveError(db.DBError):
  82.     pass
  83.  
  84.  
  85. class DBShelf(MutableMapping):
  86.     '''A shelf to hold pickled objects, built upon a bsddb DB object.  It
  87.     automatically pickles/unpickles data objects going to/from the DB.
  88.     '''
  89.     
  90.     def __init__(self, dbenv = None):
  91.         self.db = db.DB(dbenv)
  92.         self._closed = True
  93.         if HIGHEST_PROTOCOL:
  94.             self.protocol = HIGHEST_PROTOCOL
  95.         else:
  96.             self.protocol = 1
  97.  
  98.     
  99.     def __del__(self):
  100.         self.close()
  101.  
  102.     
  103.     def __getattr__(self, name):
  104.         '''Many methods we can just pass through to the DB object.
  105.         (See below)
  106.         '''
  107.         return getattr(self.db, name)
  108.  
  109.     
  110.     def __len__(self):
  111.         return len(self.db)
  112.  
  113.     
  114.     def __getitem__(self, key):
  115.         data = self.db[key]
  116.         return cPickle.loads(data)
  117.  
  118.     
  119.     def __setitem__(self, key, value):
  120.         data = _dumps(value, self.protocol)
  121.         self.db[key] = data
  122.  
  123.     
  124.     def __delitem__(self, key):
  125.         del self.db[key]
  126.  
  127.     
  128.     def keys(self, txn = None):
  129.         if txn != None:
  130.             return self.db.keys(txn)
  131.         return self.db.keys()
  132.  
  133.     if sys.version_info[0:2] >= (2, 6):
  134.         
  135.         def __iter__(self):
  136.             return self.db.__iter__()
  137.  
  138.     
  139.     
  140.     def open(self, *args, **kwargs):
  141.         self.db.open(*args, **kwargs)
  142.         self._closed = False
  143.  
  144.     
  145.     def close(self, *args, **kwargs):
  146.         self.db.close(*args, **kwargs)
  147.         self._closed = True
  148.  
  149.     
  150.     def __repr__(self):
  151.         if self._closed:
  152.             return '<DBShelf @ 0x%x - closed>' % id(self)
  153.         return repr(dict(self.iteritems()))
  154.  
  155.     
  156.     def items(self, txn = None):
  157.         if txn != None:
  158.             items = self.db.items(txn)
  159.         else:
  160.             items = self.db.items()
  161.         newitems = []
  162.         for k, v in items:
  163.             newitems.append((k, cPickle.loads(v)))
  164.         
  165.         return newitems
  166.  
  167.     
  168.     def values(self, txn = None):
  169.         if txn != None:
  170.             values = self.db.values(txn)
  171.         else:
  172.             values = self.db.values()
  173.         return map(cPickle.loads, values)
  174.  
  175.     
  176.     def __append(self, value, txn = None):
  177.         data = _dumps(value, self.protocol)
  178.         return self.db.append(data, txn)
  179.  
  180.     
  181.     def append(self, value, txn = None):
  182.         if self.get_type() == db.DB_RECNO:
  183.             return self._DBShelf__append(value, txn = txn)
  184.         raise DBShelveError, 'append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO'
  185.  
  186.     
  187.     def associate(self, secondaryDB, callback, flags = 0):
  188.         
  189.         def _shelf_callback(priKey, priData, realCallback = callback):
  190.             if sys.version_info[0] < 3 or isinstance(priData, bytes):
  191.                 data = cPickle.loads(priData)
  192.             else:
  193.                 data = cPickle.loads(bytes(priData, 'iso8859-1'))
  194.             return realCallback(priKey, data)
  195.  
  196.         return self.db.associate(secondaryDB, _shelf_callback, flags)
  197.  
  198.     
  199.     def get(self, *args, **kw):
  200.         data = apply(self.db.get, args, kw)
  201.         
  202.         try:
  203.             return cPickle.loads(data)
  204.         except (EOFError, TypeError, cPickle.UnpicklingError):
  205.             return data
  206.  
  207.  
  208.     
  209.     def get_both(self, key, value, txn = None, flags = 0):
  210.         data = _dumps(value, self.protocol)
  211.         data = self.db.get(key, data, txn, flags)
  212.         return cPickle.loads(data)
  213.  
  214.     
  215.     def cursor(self, txn = None, flags = 0):
  216.         c = DBShelfCursor(self.db.cursor(txn, flags))
  217.         c.protocol = self.protocol
  218.         return c
  219.  
  220.     
  221.     def put(self, key, value, txn = None, flags = 0):
  222.         data = _dumps(value, self.protocol)
  223.         return self.db.put(key, data, txn, flags)
  224.  
  225.     
  226.     def join(self, cursorList, flags = 0):
  227.         raise NotImplementedError
  228.  
  229.  
  230.  
  231. class DBShelfCursor:
  232.     '''
  233.     '''
  234.     
  235.     def __init__(self, cursor):
  236.         self.dbc = cursor
  237.  
  238.     
  239.     def __del__(self):
  240.         self.close()
  241.  
  242.     
  243.     def __getattr__(self, name):
  244.         '''Some methods we can just pass through to the cursor object.  (See below)'''
  245.         return getattr(self.dbc, name)
  246.  
  247.     
  248.     def dup(self, flags = 0):
  249.         c = DBShelfCursor(self.dbc.dup(flags))
  250.         c.protocol = self.protocol
  251.         return c
  252.  
  253.     
  254.     def put(self, key, value, flags = 0):
  255.         data = _dumps(value, self.protocol)
  256.         return self.dbc.put(key, data, flags)
  257.  
  258.     
  259.     def get(self, *args):
  260.         count = len(args)
  261.         method = getattr(self, 'get_%d' % count)
  262.         apply(method, args)
  263.  
  264.     
  265.     def get_1(self, flags):
  266.         rec = self.dbc.get(flags)
  267.         return self._extract(rec)
  268.  
  269.     
  270.     def get_2(self, key, flags):
  271.         rec = self.dbc.get(key, flags)
  272.         return self._extract(rec)
  273.  
  274.     
  275.     def get_3(self, key, value, flags):
  276.         data = _dumps(value, self.protocol)
  277.         rec = self.dbc.get(key, flags)
  278.         return self._extract(rec)
  279.  
  280.     
  281.     def current(self, flags = 0):
  282.         return self.get_1(flags | db.DB_CURRENT)
  283.  
  284.     
  285.     def first(self, flags = 0):
  286.         return self.get_1(flags | db.DB_FIRST)
  287.  
  288.     
  289.     def last(self, flags = 0):
  290.         return self.get_1(flags | db.DB_LAST)
  291.  
  292.     
  293.     def next(self, flags = 0):
  294.         return self.get_1(flags | db.DB_NEXT)
  295.  
  296.     
  297.     def prev(self, flags = 0):
  298.         return self.get_1(flags | db.DB_PREV)
  299.  
  300.     
  301.     def consume(self, flags = 0):
  302.         return self.get_1(flags | db.DB_CONSUME)
  303.  
  304.     
  305.     def next_dup(self, flags = 0):
  306.         return self.get_1(flags | db.DB_NEXT_DUP)
  307.  
  308.     
  309.     def next_nodup(self, flags = 0):
  310.         return self.get_1(flags | db.DB_NEXT_NODUP)
  311.  
  312.     
  313.     def prev_nodup(self, flags = 0):
  314.         return self.get_1(flags | db.DB_PREV_NODUP)
  315.  
  316.     
  317.     def get_both(self, key, value, flags = 0):
  318.         data = _dumps(value, self.protocol)
  319.         rec = self.dbc.get_both(key, flags)
  320.         return self._extract(rec)
  321.  
  322.     
  323.     def set(self, key, flags = 0):
  324.         rec = self.dbc.set(key, flags)
  325.         return self._extract(rec)
  326.  
  327.     
  328.     def set_range(self, key, flags = 0):
  329.         rec = self.dbc.set_range(key, flags)
  330.         return self._extract(rec)
  331.  
  332.     
  333.     def set_recno(self, recno, flags = 0):
  334.         rec = self.dbc.set_recno(recno, flags)
  335.         return self._extract(rec)
  336.  
  337.     set_both = get_both
  338.     
  339.     def _extract(self, rec):
  340.         if rec is None:
  341.             return None
  342.         (key, data) = rec
  343.         if sys.version_info[0] < 3 or isinstance(data, bytes):
  344.             return (key, cPickle.loads(data))
  345.         return (key, cPickle.loads(bytes(data, 'iso8859-1')))
  346.  
  347.  
  348.